home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 46 / Amiga Format CD46 (1999-10-20)(Future Publishing)(GB)[!][issue 1999-12].iso / -in_the_mag- / synth_studies / resgrep03b / source / list.h < prev    next >
C/C++ Source or Header  |  1999-09-15  |  10KB  |  279 lines
  1. #ifndef CC_LIST_H
  2. #define CC_LIST_H
  3. //
  4. // Die OOP-Definition einer 'vollständig unabhängigen' Liste.
  5. //
  6. // 12.03.1992 Andre    Idee, erste Geanken, gelesen (RKM_EXEC)
  7. // 13.03.1992 Andre    ein erster Versuch
  8. //
  9.  
  10. // Nur unter AmigaOS Intuition und die Displayfunktionen zugänglich machen
  11. #ifdef amigados
  12. extern "C" {
  13. #include <exec/types.h>
  14. #include <exec/lists.h>
  15. #include <intuition/intuition.h>
  16. #include <intuition/gadgetclass.h>
  17. #include <libraries/gadtools.h>
  18. #include <graphics/displayinfo.h>
  19. };
  20.  
  21. // Weiterhin *muß* irgendwo im entsprechende Hauptprogramm IntuitionBase
  22. // und GadToolsBase deklariert und *initialisiert* sein
  23. extern struct IntuitionBase *IntuitionBase;
  24. extern struct GadToolsBase  *GadToolsBase;
  25.  
  26. // Außerdem müssen noch die beiden nächsten Variablen deklariert und
  27. // initialisiert sein:
  28. extern struct Screen        *theScreen;
  29. extern APTR             VisualInfo;
  30. // Diese Initialisierung wird i.a. folgendermassen Durchgeführt:
  31. //
  32. //  if ( NOT( theScreen = LockPubScreen( "Workbench" )))  - oder anderen Namen
  33. //    error(...);
  34. //  if ( NOT( VisualInfo = GetVisualInfo( theScreen, TAG_DONE )))
  35. //    error(...);
  36. #endif
  37.  
  38. enum copyway
  39. {
  40.    nocopy, copy
  41. };
  42.  
  43. enum dsply
  44. {
  45.    readonly, readwrite
  46. };
  47.  
  48. class node
  49. {
  50.    node      *succ;      // Eine doppelt verkettete Liste
  51.    node      *pred;
  52.    long       pri;         // Die Priorität des Elements (klein: unwichtig)
  53.    char      *name;      // Der Name
  54.    unsigned long  pack;      // Gepackte vier Byte als Kurznamen
  55.  public:
  56.                  // Der Konstruktor
  57.    node(char *n, copyway cw=copy, long pr=0, unsigned long pa=0);
  58.    ~node(void);              // Der Destruktor
  59.  
  60.                  // Methoden der Liste
  61.  
  62.    node *getsucc(void);      // Holt den Zeiger auf den nächsten Knoten
  63.    node *getpred(void);      // Holt den Zeiger auf den Vorgänger
  64.  
  65.    void setsucc(node *s);    // Setzt den Nachfolger auf s
  66.    void setpred(node *p);    // Setzt den Vorgaenger auf p
  67.  
  68.                  // Methoden der Daten
  69.  
  70.    long getpri(void);        // Ließt die Priorität des Knotens
  71.    char *getname(void);      // Ließt den Namen des Knotens
  72.    unsigned long getpack(void); // Ließt den gepackten Namen des Knotens
  73.  
  74.    void setpri(long p);      // Setzt die Priorität des Knotens neu
  75.    void setname(char *n, copyway cw=copy); // Setzt den Namen neu
  76.                  // wenn cw auf 'copy' gesetzt ist (was
  77.                  // Voreinstellung ist), wird der Name vor der
  78.                  // Verwendung kopiert. Bei 'nocopy' wird das
  79.                  // Kopieren unterlassen.
  80.    void setpack(unsigned long pa);  // Setzt den gepackten Namen neu
  81.    void setpackchar(char *p); // Setzt den gepackten Namen neu, und zwar
  82.                  // werden dazu die ersten vier Zeichen des
  83.                  // Strings gepackt. Ist der String kürzer als
  84.                  // vier Zeichen, so wird mit Nullen aufgefüllt.
  85.  
  86.    // Die Funktionen zum Ausgeben
  87.       void print(void);
  88. };
  89.  
  90.  
  91. // Und die Klasse der Listen
  92.  
  93. class list
  94. {
  95.    node     head;         // Der vordere Anker
  96.    node     tail;         // Der hintere Anker
  97.  public:
  98.    list(void);               // Der Konstruktor
  99.    ~list(void);              // Der Destruktor
  100.  
  101.    node *getfirst(void);
  102.    node *getlast(void);
  103.  
  104.    // Allgemeine Komanndos der Liste
  105.  
  106.    void insert(node *p, node *the);  // Kettet 'the' nach 'p' in die
  107.                  // Liste ein.
  108.    void remove(node *n);     // Der Knoten 'n' wird aus der Liste entfernt.
  109.  
  110.  
  111.    // Spezielle Anfangs- und Endmethoden.
  112.  
  113.    void addhead(node *n);    // Fügt einen Knoten am Anfang einer Liste ein.
  114.    void addtail(node *n);    // Fügt einen Knoten am Anfang einer Liste ein.
  115.  
  116.    node *remhead(void);      // Nimmt den ersten Knoten aus der Liste und
  117.                  // gibt ihn zurück.
  118.    node *remtail(void);      // Nimmt den letzten Knoten aus der Liste und
  119.                  // gibt ihn zurück.
  120.  
  121.  
  122.    // Spezielle Einfügekomandos
  123.  
  124.    void enqueuepri(node *n); // Fügt den Knoten aufgrund seiner
  125.                  // Priorität in die Liste ein. Ganz vorne stehen
  126.                  // die Elemente mit kleiner Priorität.
  127.    void enqueuename(node *n); // s.o. Kriterium ist hier die
  128.                  // alphabetische Reihenfolge der Namen.
  129.    void enqueuepack(node *n); // s.o. Hier ist das Sortierkriterium
  130.                  // der gepackte Name.
  131.  
  132.    // Spezielle Suchkommandos
  133.  
  134.    node *findpri(long p);    // Sucht die Liste nach einem Element mit
  135.                  // der Priorität 'p' ab, wenn ein solches
  136.                  // existiert, wird es zurückgegeben, wenn nicht
  137.                  // wird NULL zurückgegeben.
  138.    node *findname(char *n);  // s.o. hier jedoch mit Namen
  139.    node *findpack(unsigned long pa); // s.o. aber mit Pack
  140.  
  141.  
  142.    // Sortiert kann die Liste auch werden
  143.  
  144.    void sortpri(void);       // Nach Priorität sortieren
  145.    void sortname(void);      // Nach Name sortieren
  146.    void sortpack(void);      // Nach Pack sortieren
  147.  
  148.  
  149.    // Ausgabekommandos
  150.  
  151.    void print(void);         // Gibt die Liste nach stdout aus.
  152.  
  153.    // Alles weitere nur unter AmigaOS vorhanden.
  154. #ifdef amigados
  155.  private:
  156.    struct Window *displaywin; // Der Zeiger auf das Display Window.
  157.                  // NULL, wenn das Window geschlossen.
  158.    struct Gadget *g;         // Zeiger auf das ListGadget
  159.    struct Gadget *glist;     // Die Gadgetliste für GadTools.
  160.    struct Menu     *menu;      // Die Menues des Fensters
  161.    struct List execlist;     // Die Daten des ScrollerGadget müssen in einer
  162.                  // Liste abgelegt sein. Dies ist sie!
  163.  
  164.    int change;             // Gibt an, ob die Liste gerade geändert
  165.                  // wird (dann hat 'change' den Wert 1, sonst 0)
  166.  
  167.    // Alle folgenden Variablen sind nur dazu da, den Status eines ver-
  168.    // steckten Fensters zu speichern, um dann bei einem 'reveal' wieder
  169.    // an der richtigen Stelle mit der richtigen Größe und den richtigen
  170.    // Daten zu erscheinen.
  171.    int W_hide;             // gibt an, ob das Fenster versteckt ist:
  172.                  // 0 - nicht versteckt
  173.                  // 1 - versteckt
  174.    int W_xpos, W_ypos, W_height, W_width; // Achtung!! W_height und W_width
  175.                  // sind in Anzahl der Pixel angegeben! (zum
  176.                  // Unterschied im Aufruf von display().
  177.    char *W_wintitle, *W_scrtitle;
  178.    struct MsgPort *W_mp;     // Der shard-Port.
  179.    dsply       W_ds;     // Anzeigemodus.
  180.    char       *W_format; // Format der Liste im Fenster.
  181.  
  182.    // Die drei nachfolgenden Funktionen nehmen eine besondere Bedeutung ein.
  183.    // Sie funktionieren nur auf dem Amiga, da die Intuition-Oberfläche zum
  184.    // Anzeigen und zur Auswahl eines Listenelements herangezogen wird.
  185.    // Die Parameter: Alle Paremeter, bis auf 'up' und 'msg' sind optional.
  186.    //
  187.    // ds       readonly -> Kann nur angeschaut werden
  188.    //           readwrite -> Kann angesehen und ausgewählt werden
  189.    //
  190.    // format   gibt an, welche Paramter in welcher Reihenfolge in dem
  191.    //           Display erscheinen.
  192.    //           p - Priorität (mit C-Format "%6d")
  193.    //           a - Packed als Zahl (mit C-Format "%08lx")
  194.    //           i - Packed als Text (mit C-Format "%4s")
  195.    //           n - Name (mit C-Format "%s")
  196.    //           Es werden nur diese Buchstaben erwartet, alle anderen Angaben
  197.    //           werden überlesen.
  198.    // width    Geben die Breite bzw. die Höhe des Feldes an, in dem die
  199.    // height   Liste dargestellt wird. (Anzahl der !! Zeichen !!)
  200.    //
  201.    // xpos     Gibt die Stelle an, an der das Fenster erscheint.
  202.    // ypos     (Werte in !! Pixel !!)
  203.    //
  204.    // wintitle Der Titel des Windows und der Screen.
  205.    // scrtitle
  206.    //
  207.    // up       Den ShardPort, also den Port, über den das Fenster die
  208.    //           Messages bekommt. Ist dieser angegeben, wird KEIN eigener
  209.    //           MessagePost geöffnet
  210.    //
  211.    // msg      Eine IntuiMessage, die über den ShardPort gekommen ist.
  212.    //
  213.    // Die Funktionen im einzelnen:
  214.    // - Die erste Funktion öffnet ein Fenster, zeigt die Daten der Liste
  215.    //    darin an, und wartet je nach Wert von 'ds' entweder darauf, daß das
  216.    //    Fenster geschlossen wird (falls ds==readonly) oder darauf, daß ein
  217.    //    Listenelement ausgewählt wird oder das Fenster geschlossen wird (falls
  218.    //    ds==readwrite). Falls das Fenster geschlossen wird, ohne daß ein
  219.    //    Listenelement ausgewählt wurde, wird NULL zurückgegeben, ansonsten
  220.    //    ein Zeiger auf dieses Element.
  221.    // - Die zweite Funktion öffnet das Fenster und stellt die Daten dar,
  222.    //    wartet aber NICHT auf eine Meldung von dem/der BenutzerIn sondern
  223.    //    springt sofort zurück.
  224.    // - Die Auswahl übernimmt dann die Funktion 'checkdis()', die eine Message
  225.    //    vom ShardPort als Parameter besitzt.
  226.    //    Wenn ein Listenelement ausgewählt wurde, wird ein Zeiger darauf
  227.    //    zurückgegeben.
  228.    //    Wenn die Meldung nicht für das Fenster bestimmt war, so bleibt die
  229.    //    Meldung unangetastet und es wird zusätzlich NULL zurückgegeben.
  230.    //    War die Meldung für dieses Fenster bestimmt, wird sie entsprechend
  231.    //    behandelt, der WindowZeiger in der Meldung auf NULL gesetzt und NULL
  232.    //    zurückgegeben.
  233.    //      Meldung        |      Aktion
  234.    //    ---------------------------------------------------------------------
  235.    //    Fenster schliessen  |  Das Fenster wird 'versteckt' (hide)
  236.    // - 'hide()' versteckt das Fenster explizit. Dabei bleiben interne
  237.    //    Datenstrukturen erhalten und die Position des Fensters wird
  238.    //    gespeichert. (Kann auch aufgerufen werden, wenn Fenster schon
  239.    //    versteckt ist.)
  240.    // - 'reveal()' öffnet ein verstecktes Window.
  241.    // - 'closedis()' schließt ein geöffnetes oder verstecktes Window und gibt
  242.    //    sämtliche Recourcen wieder frei.
  243.  private:
  244.    void doformat(char *buffer, char *format, node *n);
  245.    int    domsg(struct IntuiMessage *msg);
  246.    void freeexeclist(void);
  247.    void makeexeclist(char *format);
  248.    node *num2node(int num);
  249.    char *pack2string(unsigned long pa);
  250.  
  251.  public:
  252.    node *display(dsply ds=readonly, char *format="n",
  253.          int width=16, int height=16,
  254.          int xpos=50, int ypos=20,
  255.          char *wintitle="Display List", char *scrtitle="Display");
  256.    int    display(struct MsgPort *up,
  257.         struct Menu *menu=NULL,
  258.          dsply ds=readonly, char *format="n",
  259.          int width=16, int height=16,
  260.          int xpos=50, int ypos=20,
  261.          char *wintitle="Display List", char *scrtitle="Display");
  262.    node *checkdis(struct IntuiMessage *msg);
  263.    void hide(void);
  264.    int    reveal(void);
  265.    void closedis(void);
  266.    // Und Funktionen, die es erlauben während das Window angezeigt wird die
  267.    // Liste zu ändern.
  268.    void start_change(void);
  269.    void end_change(void);
  270.  
  271.    struct MsgPort *getmp(void);
  272.    struct Menu *getmenu(void);
  273.    struct Window *getwin(void);
  274. #endif
  275.  
  276. };
  277.  
  278. #endif
  279.